home *** CD-ROM | disk | FTP | other *** search
/ Games of Daze / Infomagic - Games of Daze (Summer 1995) (Disc 1 of 2).iso / djgpp / contrib / pdcurs22 / src / portable / border.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-01-26  |  12.0 KB  |  470 lines
  1. /*
  2. ***************************************************************************
  3. * This file comprises part of PDCurses. PDCurses is Public Domain software.
  4. * You may use this code for whatever purposes you desire. This software
  5. * is provided AS IS with NO WARRANTY whatsoever.
  6. * Should this software be used in another application, an acknowledgement
  7. * that PDCurses code is used would be appreciated, but is not mandatory.
  8. *
  9. * Any changes which you make to this software which may improve or enhance
  10. * it, should be forwarded to the current maintainer for the benefit of 
  11. * other users.
  12. *
  13. * The only restriction placed on this code is that no distribution of
  14. * modified PDCurses code be made under the PDCurses name, by anyone
  15. * other than the current maintainer.
  16. * 
  17. * See the file maintain.er for details of the current maintainer.
  18. ***************************************************************************
  19. */
  20. #define    CURSES_LIBRARY    1
  21. #include <curses.h>
  22.  
  23. /* undefine any macros for functions defined in this module */
  24. #undef    border
  25. #undef    wborder
  26. #undef    box
  27. #undef    hline
  28. #undef    whline
  29. #undef    vline
  30. #undef    wvline
  31.  
  32. /* undefine any macros for functions called by this module if in debug mode */
  33. #ifdef PDCDEBUG
  34. #endif
  35.  
  36. #ifdef PDCDEBUG
  37. char *rcsid_border  = "$Id$";
  38. #endif
  39.  
  40. /*man-start*********************************************************************
  41.  
  42.   Name:                                                        border
  43.  
  44.   Synopsis:
  45.       int border(chtype ls, chtype rs, chtype ts, chtype bs, chtype tl, 
  46.                  chtype tr, chtype bl, chtype br);
  47.       int wborder(WINDOW *win, chtype ls, chtype rs, chtype ts, 
  48.                   chtype bs, chtype tl, chtype tr, chtype bl, chtype br);
  49.       int box(WINDOW *win, chtype verch, chtype horch);
  50.       int hline(chtype ch, int n);
  51.       int vline(chtype ch, int n);
  52.       int whline(WINDOW *win, chtype ch, int n);
  53.       int wvline(WINDOW *win, chtype ch, int n);
  54.  
  55.   X/Open Description:
  56.      The border(), wborder(), and box() routines, a border is drawn
  57.      around the edge of the window. If any of the arguments is zero,
  58.      an appropriate default is used. These default values are specified
  59.      in <curses.h>. The arguments and defaults to these functions are:
  60.          ls    left side of border        ACS_VLINE
  61.          rs    right side of border        ACS_VLINE
  62.          ts    top side of border        ACS_HLINE
  63.          bs    bottom side of border        ACS_HLINE
  64.          tl    top left corner of border    ACS_ULCORNER
  65.          tr    top right corner of border    ACS_URCORNER
  66.          bl    bottom left corner of border    ACS_BLCORNER
  67.          br    bottom right corner of border    ACS_BLCORNER
  68.  
  69.      The hline() and whline() functions draw a left to right line
  70.      using ch starting from the current cursor position. The cursor
  71.      position does not change. The line is at most n characters long
  72.      or as many as will fit in the window.
  73.  
  74.      The vline() and wvline() functions draw a top to bottom line
  75.      using ch starting from the current cursor position. The cursor
  76.      position does not change. The line is at most n characters long
  77.      or as many as will fit in the window.
  78.  
  79.      border(), box(), hline(), and vline() are implemented as macros.
  80.  
  81.   X/Open Return Value:
  82.      These functions return OK on success and ERR on error.
  83.  
  84.   X/Open Errors:
  85.      No errors are defined for these functions.
  86.  
  87.   Portability                             X/Open    BSD    SYS V
  88.                                           Dec '88
  89.       border                                -        -      4.0
  90.       wborder                               -        -      4.0
  91.       box                                   Y        Y       Y
  92.       hline                                 -        -      4.0
  93.       whline                                -        -      4.0
  94.       vline                                 -        -      4.0
  95.       wvline                                -        -      4.0
  96.  
  97. **man-end**********************************************************************/
  98.  
  99. /***********************************************************************/
  100. int wborder(WINDOW *win, chtype ls, chtype rs, chtype ts, 
  101.             chtype bs, chtype tl, chtype tr, chtype bl, chtype br)
  102. /***********************************************************************/
  103. {
  104.     int ymax,xmax;
  105.     int ymin,xmin;
  106.     int    i;
  107.     chtype    vattr;
  108.     chtype    hattr;
  109.  
  110. #ifdef PDCDEBUG
  111.     if (trace_on) PDC_debug("wborder() - called\n");
  112. #endif
  113.  
  114.     if (win == (WINDOW *)NULL)
  115.         return( ERR );
  116.     ymax = win->_maxy - 1;
  117.     xmax = win->_maxx - 1;
  118.     ymin = 0;
  119.     xmin = 0;
  120.  
  121.     if ((ts    & A_ATTRIBUTES)    == 0)
  122.        hattr    = win->_attrs;
  123.     else
  124.        if ((ts & A_COLOR) == 0)
  125.           hattr = (ts & A_ATTRIBUTES) | win->_attrs;
  126.        else
  127.           hattr = (ts & A_ATTRIBUTES);
  128.  
  129.     if ((ls    & A_ATTRIBUTES)    == 0)
  130.        vattr    = win->_attrs;
  131.     else
  132.        if ((ls & A_COLOR) == 0)
  133.           vattr = (ls & A_ATTRIBUTES) | win->_attrs;
  134.        else
  135.           vattr = (ls & A_ATTRIBUTES);
  136.  
  137.     ls = (ls == 0) ? ACS_VLINE | vattr : ls;
  138.     rs = (rs == 0) ? ACS_VLINE | vattr : rs;
  139.     ts = (ts == 0) ? ACS_HLINE | hattr : ts;
  140.     bs = (bs == 0) ? ACS_HLINE | hattr : bs;
  141.     tl = (tl == 0) ? ACS_ULCORNER | vattr : tl;
  142.     tr = (tr == 0) ? ACS_URCORNER | vattr : tr;
  143.     bl = (bl == 0) ? ACS_LLCORNER | vattr : bl;
  144.     br = (br == 0) ? ACS_LRCORNER | vattr : br;
  145.  
  146.     ls = (ls & A_ATTRIBUTES) ? ls : ls | vattr;
  147.     rs = (rs & A_ATTRIBUTES) ? rs : rs | vattr;
  148.     ts = (ts & A_ATTRIBUTES) ? ts : ts | hattr;
  149.     bs = (bs & A_ATTRIBUTES) ? bs : bs | hattr;
  150.     tl = (tl & A_ATTRIBUTES) ? tl : tl | vattr;
  151.     tr = (tr & A_ATTRIBUTES) ? tr : tr | vattr;
  152.     bl = (bl & A_ATTRIBUTES) ? bl : bl | vattr;
  153.     br = (br & A_ATTRIBUTES) ? br : br | vattr;
  154.  
  155.     for (i = xmin + 1; i <= xmax - 1; i++)
  156.     {
  157.         win->_y[ymin][i] = ts;
  158.         win->_y[ymax][i] = bs;
  159.     }
  160.  
  161.     for (i = ymin + 1; i <= ymax - 1; i++)
  162.     {
  163.         win->_y[i][xmin] = ls;
  164.         win->_y[i][xmax] = rs;
  165.     }
  166.  
  167.     win->_y[ymin][xmin] = tl;
  168.     win->_y[ymin][xmax] = tr;
  169.     win->_y[ymax][xmin] = bl;
  170.     win->_y[ymax][xmax] = br;
  171.  
  172.     for (i = ymin; i <= ymax; i++)
  173.     {
  174.         if (win->_firstch[i] == _NO_CHANGE)
  175.         {
  176.             win->_firstch[i] = xmin;
  177.             win->_lastch[i] = xmax;
  178.         }
  179.         else
  180.         {
  181.             win->_firstch[i] = min(win->_firstch[i], xmin);
  182.             win->_lastch[i] = max(win->_lastch[i], xmax);
  183.         }
  184.     }
  185.     return (OK);
  186. }
  187. /***********************************************************************/
  188. int border(chtype ls, chtype rs, chtype ts, chtype bs,
  189.            chtype tl, chtype tr, chtype bl, chtype br)
  190. /***********************************************************************/
  191. {
  192.     int ymax,xmax;
  193.     int ymin,xmin;
  194.     int    i;
  195.  
  196. #ifdef PDCDEBUG
  197.     if (trace_on) PDC_debug("border() - called\n");
  198. #endif
  199.  
  200.     if (stdscr == (WINDOW *)NULL)
  201.         return( ERR );
  202.  
  203.     return(wborder(stdscr,ls,rs,ts,bs,tl,tr,bl,br));
  204. }
  205. /***********************************************************************/
  206. int box(WINDOW *win, chtype verch, chtype horch)
  207. /***********************************************************************/
  208. {
  209. #ifdef PDCDEBUG
  210.     if (trace_on) PDC_debug("box() - called\n");
  211. #endif
  212.  
  213.     if (win == (WINDOW *)NULL)
  214.         return( ERR );
  215.  
  216.     return(wborder(win,verch,verch,horch,horch,0,0,0,0));
  217. }
  218. /***********************************************************************/
  219. int    hline(chtype ch, int n)
  220. /***********************************************************************/
  221. {
  222.     chtype    attr;
  223.     int    startpos;
  224.     int    endpos;
  225.  
  226. #ifdef PDCDEBUG
  227.     if (trace_on) PDC_debug("hline() - called\n");
  228. #endif
  229.  
  230.     if (stdscr == (WINDOW *)NULL)
  231.         return( ERR );
  232.  
  233.     if (n < 1)
  234.         return( ERR );
  235.  
  236.     endpos = min(stdscr->_curx + n -1, stdscr->_maxx);
  237.  
  238.     /*
  239.     ** If the incoming character doesn't have it's own attribute
  240.     ** then use the current attributes for the window.
  241.     */
  242.  
  243.     if ((ch & A_ATTRIBUTES) == 0)
  244.         attr = stdscr->_attrs;
  245.     else
  246.         if ((ch & A_COLOR) == 0)
  247.             attr = (ch & A_ATTRIBUTES) | stdscr->_attrs;
  248.         else
  249.             attr = (ch & A_ATTRIBUTES);
  250.  
  251.     ch &= A_CHARTEXT;
  252.  
  253.     /*
  254.     ** If the incoming character is zero then use the default horizontal
  255.     ** line character.
  256.     */
  257.  
  258.     if (ch == 0)
  259.         ch = ACS_HLINE;
  260.  
  261.     ch |= attr;
  262.     startpos = stdscr->_curx;
  263.  
  264.     for (n = stdscr->_curx; n <= endpos; n++)
  265.         stdscr->_y[stdscr->_cury][n] = ch;
  266.  
  267.     n = stdscr->_cury;
  268.  
  269.     if (stdscr->_firstch[n] == _NO_CHANGE)
  270.     {
  271.         stdscr->_firstch[n] = startpos;
  272.         stdscr->_lastch[n] = endpos;
  273.     }
  274.     else
  275.     {
  276.         stdscr->_firstch[n] = min(stdscr->_firstch[n], startpos);
  277.         stdscr->_lastch[n] = max(stdscr->_lastch[n], endpos);
  278.     }
  279.  
  280.     return (OK);
  281. }
  282. /***********************************************************************/
  283. int    whline(WINDOW *win, chtype ch, int n)
  284. /***********************************************************************/
  285. {
  286.     chtype    attr;
  287.     int    startpos;
  288.     int    endpos;
  289.  
  290. #ifdef PDCDEBUG
  291.     if (trace_on) PDC_debug("whline() - called\n");
  292. #endif
  293.  
  294.     if (win == (WINDOW *)NULL)
  295.         return( ERR );
  296.  
  297.     if (n < 1)
  298.         return( ERR );
  299.  
  300.     endpos = min(win->_curx + n -1, win->_maxx);
  301.  
  302.     /*
  303.     ** If the incoming character doesn't have it's own attribute
  304.     ** then use the current attributes for the window.
  305.     */
  306.  
  307.     if ((ch & A_ATTRIBUTES) == 0)
  308.         attr = win->_attrs;
  309.     else
  310.         if ((ch & A_COLOR) == 0)
  311.             attr = (ch & A_ATTRIBUTES) | win->_attrs;
  312.         else
  313.             attr = (ch & A_ATTRIBUTES);
  314.  
  315.     ch &= A_CHARTEXT;
  316.  
  317.     /*
  318.     ** If the incoming character is zero then use the default horizontal
  319.     ** line character.
  320.     */
  321.  
  322.     if (ch == 0)
  323.         ch = ACS_HLINE;
  324.  
  325.     ch |= attr;
  326.     startpos = win->_curx;
  327.  
  328.     for (n = win->_curx; n <= endpos; n++)
  329.         win->_y[win->_cury][n] = ch;
  330.  
  331.     n = win->_cury;
  332.  
  333.     if (win->_firstch[n] == _NO_CHANGE)
  334.     {
  335.         win->_firstch[n] = startpos;
  336.         win->_lastch[n] = endpos;
  337.     }
  338.     else
  339.     {
  340.         win->_firstch[n] = min(win->_firstch[n], startpos);
  341.         win->_lastch[n] = max(win->_lastch[n], endpos);
  342.     }
  343.  
  344.     return (OK);
  345. }
  346. /***********************************************************************/
  347. int    vline(chtype ch, int n)
  348. /***********************************************************************/
  349. {
  350.     chtype    attr;
  351.     int    endpos;
  352.  
  353. #ifdef PDCDEBUG
  354.     if (trace_on) PDC_debug("vline() - called\n");
  355. #endif
  356.  
  357.     if (stdscr == (WINDOW *)NULL)
  358.         return( ERR );
  359.  
  360.     if (n < 1)
  361.         return( ERR );
  362.  
  363.     endpos = min(stdscr->_cury + n -1, stdscr->_maxy);
  364.  
  365.     /*
  366.     ** If the incoming character doesn't have it's own attribute
  367.     ** then use the current attributes for the window.
  368.     */
  369.  
  370.     if ((ch & A_ATTRIBUTES) == 0)
  371.         attr = stdscr->_attrs;
  372.     else
  373.         if ((ch & A_COLOR) == 0)
  374.             attr = (ch & A_ATTRIBUTES) | stdscr->_attrs;
  375.         else
  376.             attr = (ch & A_ATTRIBUTES);
  377.  
  378.     ch &= A_CHARTEXT;
  379.  
  380.     /*
  381.     ** If the incoming character is zero then use the default vertical
  382.     ** line character.
  383.     */
  384.  
  385.     if (ch == 0)
  386.         ch = ACS_VLINE;
  387.  
  388.     ch |= attr;
  389.  
  390.     for (n = stdscr->_cury; n <= endpos; n++)
  391.     {
  392.         stdscr->_y[n][stdscr->_curx] = ch;
  393.  
  394.         if (stdscr->_firstch[n] == _NO_CHANGE)
  395.         {
  396.             stdscr->_firstch[n] = stdscr->_curx;
  397.             stdscr->_lastch[n] = stdscr->_curx;
  398.         }
  399.         else
  400.         {
  401.             stdscr->_firstch[n] = min(stdscr->_firstch[n], stdscr->_curx);
  402.             stdscr->_lastch[n] = max(stdscr->_lastch[n], stdscr->_curx);
  403.         }
  404.     }
  405.  
  406.     return (OK);
  407. }
  408. /***********************************************************************/
  409. int    wvline(WINDOW *win, chtype ch, int n)
  410. /***********************************************************************/
  411. {
  412.     chtype    attr;
  413.     int    endpos;
  414.  
  415. #ifdef PDCDEBUG
  416.     if (trace_on) PDC_debug("wvline() - called\n");
  417. #endif
  418.  
  419.     if (win == (WINDOW *)NULL)
  420.         return( ERR );
  421.  
  422.     if (n < 1)
  423.         return( ERR );
  424.  
  425.     endpos = min(win->_cury + n -1, win->_maxy);
  426.  
  427.     /*
  428.     ** If the incoming character doesn't have it's own attribute
  429.     ** then use the current attributes for the window.
  430.     */
  431.  
  432.     if ((ch & A_ATTRIBUTES) == 0)
  433.         attr = win->_attrs;
  434.     else
  435.         if ((ch & A_COLOR) == 0)
  436.             attr = (ch & A_ATTRIBUTES) | win->_attrs;
  437.         else
  438.             attr = (ch & A_ATTRIBUTES);
  439.  
  440.     ch &= A_CHARTEXT;
  441.  
  442.     /*
  443.     ** If the incoming character is zero then use the default vertical
  444.     ** line character.
  445.     */
  446.  
  447.     if (ch == 0)
  448.         ch = ACS_VLINE;
  449.  
  450.     ch |= attr;
  451.  
  452.     for (n = win->_cury; n <= endpos; n++)
  453.     {
  454.         win->_y[n][win->_curx] = ch;
  455.  
  456.         if (win->_firstch[n] == _NO_CHANGE)
  457.         {
  458.             win->_firstch[n] = win->_curx;
  459.             win->_lastch[n] = win->_curx;
  460.         }
  461.         else
  462.         {
  463.             win->_firstch[n] = min(win->_firstch[n], win->_curx);
  464.             win->_lastch[n] = max(win->_lastch[n], win->_curx);
  465.         }
  466.     }
  467.  
  468.     return (OK);
  469. }
  470.